home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Debugger / RTDC.Mod (.txt) < prev    next >
Encoding:
Oberon Text  |  1995-08-30  |  7.6 KB  |  200 lines  |  [TEXT/.Ob4]
  1. Syntax10.Scn.Fnt
  2. StampElems
  3. Alloc
  4. 30 Aug 95
  5. InfoElems
  6. Alloc
  7. Syntax10.Scn.Fnt
  8. StampElems
  9. Alloc
  10. 30 Aug 95
  11. "Title": Run time debugger
  12. "Author": mah
  13. "Abstract": Compiler information grabber
  14. "Keywords": 
  15. "Version": 
  16. "From":  25.10.94 16:53:38
  17. "Until": 
  18. "Changes": 
  19. ParcElems
  20. Alloc
  21. Syntax10i.Scn.Fnt
  22. Syntax10b.Scn.Fnt
  23. FoldElems
  24. Syntax10.Scn.Fnt
  25. Syntax10b.Scn.Fnt
  26.         pc-: POINTER TO ARRAY OF SHORTINT;
  27.         pos-: POINTER TO ARRAY OF LONGINT;
  28.     END;
  29. Syntax10.Scn.Fnt
  30. Syntax10i.Scn.Fnt
  31.         name: ARRAY 32 OF CHAR;                        (* modul name of entry *)
  32.         mod: Modules.Module;                            (* modul descriptor *)
  33.         sym: Sym;                                        (* symbol info of module 'name' *)
  34.         stat: Stat;                                        (* statements of module 'name' *)
  35.     END;
  36. Syntax10.Scn.Fnt
  37. Syntax10i.Scn.Fnt
  38.     pos, i: INTEGER;
  39.     indexcheckoff, typecheckoff: BOOLEAN;
  40.     trap: Modules.TrapDescPtr;
  41. BEGIN
  42.     indexcheckoff := TRUE; typecheckoff := TRUE; pos := 1; o[0] := 'n';
  43.     FOR i := 0 TO mod.noftraps-1 DO
  44.         trap := SYS.VAL (Modules.TrapDescPtr, mod.traps+i*SIZE (Modules.TrapDesc));
  45.         CASE trap.trapno OF
  46.             1: indexcheckoff := FALSE    (* has index check -> no 'x' parameter *)
  47.         |    4: typecheckoff := FALSE        (* has type check -> no 't' parameter *)
  48.         |    7: pos := 0                    (* has NIL check -> no 'n' parameter *)
  49.         ELSE
  50.         END
  51.     END;
  52.     IF indexcheckoff THEN o[pos] := 'x'; INC (pos) END;
  53.     IF typecheckoff THEN o[pos] := 't'; INC (pos) END;
  54.     o[pos] := 'f'; o[pos+1] := CHR(0)        (* add findpc option *)
  55. END GetOptions;
  56. Syntax10.Scn.Fnt
  57. BEGIN
  58.     WHILE (obj # NIL) & (obj.name # name) DO
  59.         IF name < obj.name THEN  obj := obj.left
  60.         ELSE  obj := obj.right END
  61.     END;
  62.     RETURN obj
  63. END Find;
  64. Syntax10.Scn.Fnt
  65. VAR cnt: INTEGER; s: OPV.Stats; i: INTEGER;
  66. BEGIN
  67.     s := OPV.stats; cnt := 0;
  68.     WHILE s # NIL DO INC (cnt, s.numStat); s := s.next END;
  69.     NEW (stat.pc, cnt); NEW (stat.pos, cnt);
  70.     s := OPV.stats; cnt := 0;
  71.     WHILE s # NIL DO
  72.         FOR i := 0 TO s.numStat-1 DO
  73.             stat.pc[cnt+i] := s.pc[i];
  74.             stat.pos[cnt+i] := s.pos[i];
  75.         END;
  76.         INC (cnt, s.numStat); s := s.next
  77. END ConvertStats;
  78. Syntax10.Scn.Fnt
  79. VAR i: INTEGER;
  80. BEGIN
  81.     FOR i := 0 TO maxnofmods-1 DO
  82.         modCache[i].mod := NIL;
  83.         modCache[i].sym := NIL;
  84.         modCache[i].stat.pc := NIL;
  85.         modCache[i].stat.pos := NIL
  86.     END;
  87.     nextslot := 0
  88. END Release;
  89. Syntax10.Scn.Fnt
  90.     PROCEDURE Scan (o: Sym);
  91.     BEGIN IF o # NIL THEN Scan (o.left); proc (o); Scan (o.right) END
  92.     END Scan;
  93. BEGIN Scan (scope)
  94. END ScanScope;
  95. Syntax10.Scn.Fnt
  96. VAR idx: INTEGER;
  97. BEGIN
  98.     idx := LoadModule (Modules.ThisMod (name));
  99.     IF idx = -1 THEN stats.pc := NIL ELSE stats := modCache[idx].stat END
  100. END Statements;
  101. Syntax10.Scn.Fnt
  102. Syntax10i.Scn.Fnt
  103. VAR sym: Sym;
  104. BEGIN
  105.     Symbols (type.module.name, sym);
  106.     IF sym = NIL THEN Symbols (module.name, sym) END;    (* get info of type as imported in module *)
  107.     ASSERT (sym # NIL);
  108.     RETURN Find (sym, type.name)
  109. END FindType;
  110. Syntax10.Scn.Fnt
  111. Syntax10i.Scn.Fnt
  112.     o, parentScope: Sym;
  113.     parentProc: RTDT.Proc;
  114.     mod: Modules.Module;
  115.     i, j: INTEGER;
  116.     n: ARRAY 64 OF CHAR;
  117. BEGIN
  118.     i := 0; WHILE (proc.name[i] # 0X) & (proc.name[i] # '.') DO INC (i) END;
  119.     IF proc.name[i] = '.' THEN            (* typebound   typename.procname *)
  120.         COPY (proc.name, n); n[i] := 0X;
  121.         Symbols (proc.modName, o);
  122.         o := Find (o, n);
  123.         j := 0; REPEAT n[j] := proc.name[i+1]; INC (i); INC (j) UNTIL proc.name[i] = 0X;    
  124.         IF o.typ.form = 13 THEN o := o.typ.BaseTyp.strobj END;     (* pointer as self parameter *)
  125.         o := Find (o.typ.link, n);
  126.         RETURN o.scope.right
  127.     ELSE        (* normal or local procedure (takes care of local procedures) *)
  128.         parentProc := proc.up;
  129.         WHILE (parentProc # NIL) & (parentProc.modName = proc.modName) DO
  130.             parentScope := FindProc (parentProc);
  131.             IF parentScope # NIL THEN
  132.                 o := Find (parentScope, proc.name);
  133.                 IF o#NIL THEN RETURN o.scope.right END
  134.             END;
  135.             parentProc := parentProc.up
  136.         END;
  137.         Symbols (proc.modName, o);
  138.         o := Find (o, proc.name);
  139.         RETURN o.scope.right
  140. END FindProc;
  141. MODULE RTDC; (* Run time debugger: Compiler reference & position information; mah 25.10.94 (
  142. IMPORT OPV := POPV, OPT := POPT, Modules, SYS := SYSTEM, Texts, TextFrames, Compiler, Types, FoldElems, RTDT;
  143. CONST
  144.     maxnofmods = 5;                                        (* cache size: max # of modules cached *)
  145.     Sym* = OPT.Object;                                    (* alias to hide compiler type *)
  146.     Type* = OPT.Struct;
  147.     Stat* = RECORD
  148.     ModuleCache = RECORD 
  149.     ScanProc*  = PROCEDURE (obj : Sym);                (* iterator type for scanning scopes *)
  150.     nextslot: INTEGER;                                         (* next slot to be used  in cache (round robin) *)
  151.     modCache: ARRAY maxnofmods OF ModuleCache;    (* modul cache *)
  152. PROCEDURE GetOptions (mod: Modules.Module; VAR o: ARRAY OF CHAR);
  153. PROCEDURE Find (obj: Sym; VAR name: ARRAY OF CHAR) : Sym;
  154. PROCEDURE ConvertStats (VAR stat: Stat);
  155. PROCEDURE LoadModule (mod: Modules.Module) : INTEGER;
  156.     slot, i: INTEGER;
  157.     name: ARRAY 36 OF CHAR;
  158.     source, out: Texts.Text;
  159.     r: Texts.Reader;
  160.     option: ARRAY 5 OF CHAR;
  161.     err: BOOLEAN;
  162. BEGIN
  163.     IF mod = NIL THEN RETURN -1 END;
  164.     slot := 0;
  165.     WHILE (slot # maxnofmods) & (mod.name # modCache[slot].name) DO INC (slot) END;
  166.     IF slot = maxnofmods THEN slot := nextslot
  167.     ELSIF modCache[slot].mod = mod THEN RETURN slot END;
  168.     COPY (mod.name, name);
  169.     i := 0; WHILE name[i] # 0X DO INC (i) END;
  170.     name[i] := '.'; name[i+1] := 'M'; name[i+2] := 'o'; name[i+3] := 'd'; name[i+4] := CHR(0);
  171.     source := TextFrames.Text (name);
  172.     IF source.len = 0 THEN RETURN -1 END;
  173.     FoldElems.ExpandAll (source, 0, TRUE);
  174.     Texts.OpenReader (r, source, 0);
  175.     out := TextFrames.Text ("");
  176.     GetOptions (mod, option);
  177.     Compiler.Module (r, option, 0, out, err);
  178.     IF (Compiler.mainMod = NIL) OR (OPV.stats = NIL) THEN RETURN -1 END;
  179.     modCache[slot].mod := mod;
  180.     modCache[slot].sym := Compiler.mainMod;
  181.     COPY (mod.name, modCache[slot].name);
  182.     ConvertStats (modCache[slot].stat);
  183.     IF slot = nextslot THEN nextslot := (nextslot+1) MOD maxnofmods END;
  184.     Compiler.mainMod := NIL;                            (* help garbage collector *)
  185.     OPV.stats := NIL;    
  186.     RETURN slot
  187. END LoadModule;
  188. PROCEDURE Release*;
  189. PROCEDURE ScanScope* (scope: Sym; proc: ScanProc);
  190. PROCEDURE Statements* (name: ARRAY OF CHAR; VAR stats: Stat);
  191. PROCEDURE Symbols* (name: ARRAY OF CHAR; VAR syms: Sym);
  192. VAR idx: INTEGER;
  193. BEGIN
  194.     idx := LoadModule (Modules.ThisMod (name));
  195.     IF idx = -1 THEN syms := NIL ELSE syms := modCache[idx].sym END
  196. END Symbols;
  197. PROCEDURE FindType* (type: Types.Type; module: Modules.Module) : Sym;
  198. PROCEDURE FindProc* (proc : RTDT.Proc) : Sym;
  199. END RTDC.
  200.